 package com.bitoon.basketdudes.web.admin;

import com.bitoon.basketdudes.web.*;
import com.bitoon.basketdudes.web.datos.EstadisticaEquipo;
import com.bitoon.basketdudes.web.datos.InfoCabeceraXHR;
import com.bitoon.basketdudes.web.jpa.*;
import com.bitoon.tienda.jpa.Ingreso;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import javax.persistence.*;
import org.apache.log4j.Logger;
import java.util.regex.*;

public class DetalleManagerAdmin extends DetalleManager {

    //para recibir los parametros del formulario de modificacion del admin
    private boolean error;
    private boolean error_patron;
    private boolean modificar;
    private boolean estado;
    private int id;
    private String nickMostrar;
    private String nick;
    private String email;
    private int status;
    private int robinson; //newslletter
    private int reputacion;
    private int longMinimoNick = 4;
    private int longMaximoNick = 16;
    private static String patternNick = "[0-9a-zA-Z._-]+";
    private static String patternEmail = "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}";

    //para la paginacion de torneos de un usuario
    private List<Torneo> torneos;
    private List<Ingreso> listaIngresos;
    private List<Movimiento> listaMovimientos;
    private InfoCabeceraXHR cabecera;
    private int pagina = 1;
    private int cuantos;
    
    //para la informacion financiera
    private int[] resumen = new int[3]; //ingresos - gastos - total
    private String bitoons;
    private int seccion;

    private String dias;     //dias de baneo
    private int horas;       //horas de baneo
    private String fechaFin; //fecha concreta para el baneo

    private Logger log = Logger.getLogger(DetalleManagerAdmin.class);
    
    //acceso a la clase estatica BaseActionAdmin
    protected BaseActionAdmin bsaadmin = BaseActionAdmin.getInstance();

    @Override
    public String execute() {
        String retorno = SUCCESS;

        Usuario manager = consultaManager(getNickManager());
        if (manager == null) {
            retorno = NOT_FOUND;
        } else {
            retorno = SUCCESS;
            this.setManager(manager);
            this.setListaEquiposManager(manager.getEquipos());
        }

        return retorno;
    }

    public List<DatoTipoCarta> getCartasEquipoAdmin(int idEquipo) {
        EntityManager em = null;
        List<DatoTipoCarta> listaCartas = null;

        try {
            em = emfBasket.createEntityManager(); // checked

            log.debug("Equipo_id: "+idEquipo);

            Query q  = em.createNamedQuery("CartaEquipo.findByEquipoIdGroupByMcartaId",DatoTipoCarta.class);
            q.setParameter("equipoId", idEquipo);

            listaCartas = (List<DatoTipoCarta>)q.getResultList();

            if(listaCartas.isEmpty()){
                listaCartas = null;
            }
        } catch (NoResultException e) {
            log.debug("[getCartasEquipo][armario del equipo " + idEquipo + " no encontrado]");
        } catch (Exception e) {
            log.error("[getCartasEquipo]: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return listaCartas;
    }

    public String consultaManagerAdmin() {
        EntityManager em = null;
        String retorno = SUCCESS;

        if(isModificar()){
            //si hay que modificar la informacion
            retorno = modificarManager();
        }else{
            //si hay que consultar la información
            try {
                log.debug("Consulto: " + isModificar()+ "-" + getId());
                em = emfBasket.createEntityManager(); // checked

                Query q  = em.createNamedQuery("Usuario.findById");
                q.setParameter("id", getId());

                setManager((Usuario)q.getSingleResult());

                if(getManager()!=null){
                    //recogemos su lista de equipos
                    this.setListaEquiposManager(getManager().getEquipos());
                    //para cada equipo realizamos distintas operaciones: estadisticas, armario, cartas
                    EstadisticaEquipo estadistica = null;
                    for(int i=0;i<getListaEquiposManager().size();++i){
                        //generamos sus estadisticas
                        estadistica = new EstadisticaEquipo();
                        estadistica.calculaMedia(getListaEquiposManager().get(i).getPlantilla());
                        getListaEquiposManager().get(i).setEstadisticaEquipo(estadistica);
                    }
                }
            } catch (NoResultException e) {
                log.debug("[getManager][usuario " + getNickManager() + " no encontrado]");
            } catch (Exception e) {
                log.error("[getManager]: ", e);
            } finally {
                try { em.close(); } catch (Exception e) { }
            }
        }
        return retorno;
    }

    private String modificarManager(){
        EntityManager em = null;
        setError(false);
        String retorno = "mod_ok";
        
        log.debug("Modifico: " + isModificar()+ "-" + nickMostrar);

        try {
            if(comprobacionesPreviasRegistro()){
                em = emfBasket.createEntityManager(); // checked

                //comprobar que no existe un manager con el mismo nick ya
                Usuario userSiExiste=null;
                Query q = null;
                try{
                    q  = em.createNamedQuery("Usuario.findByNickAdmin");
                    q.setParameter("nick", nickMostrar.toLowerCase());
                    userSiExiste = (Usuario)q.getSingleResult();
                }catch (NoResultException e) {
                    log.debug("[modificarManager][usuario " + getNickManager() + " no encontrado]");
                }

                q  = em.createNamedQuery("Usuario.findById");
                q.setParameter("id", getId());

                Usuario managerModifica = (Usuario)q.getSingleResult();

                //si no existe ese usuario ya o es el mismo,modifico
                //log.debug("[modificarManager] Mm_id: " + managerModifica.getId() + " Ue_id: " + userSiExiste.getId() + " result: "+ (managerModifica.getId()==userSiExiste.getId()));
                if(userSiExiste==null || (managerModifica.getId()==userSiExiste.getId())){

                    q  = em.createNamedQuery("Usuario.findById");
                    q.setParameter("id", getId());

                    setManager(managerModifica);

                    em.getTransaction().begin();

                    getManager().setNick(nickMostrar.toLowerCase());
                    getManager().setNickMostrar(nickMostrar);
                    getManager().setEmail(email);
                    //si cambia de cualquier estado a activo(y no estaba activo ya)
                    //le ponemos su fecha de admision a la actual
                    log.debug("status: " +status + " - user.status: " + getManager().getStatus());
                    if(status==1 &&  getManager().getStatus()!=1){
                        getManager().setfAdmision(new Date());
                    }
                    getManager().setStatus(status);
                    getManager().setRobinson(robinson);
                    getManager().setReputacion(reputacion);

                    //solo baneamos si el status es temporal(5)
                    if(status==5){
                        getManager().setfAdmision(banear());
                    }//fin baneo

                    
                    em.persist(getManager());

                    em.getTransaction().commit();

                    setNickManager(nickMostrar.toLowerCase());

                    log.debug("[modificarManager][usuario modificado correctamente]");
                
                }else{
                    log.debug("[modificarManager] Usuario existe con ese nick YA!");
                    retorno = "mod_error";
                }
            }else{
                log.debug("[modificarManager] ERROR");
                retorno = "mod_error_patron";
            }
        } catch (Exception e) {
            log.error("[modificarManager]: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

    private Date banear(){
        //baneo temporal - comprobamos si se esta intentando banear
        //si es baneo concreto(por el calendario) o no
        log.debug("[banear] fechaFin: " + fechaFin + "dias: " + dias + "horas: "+horas);

        Date fecha_baneo = new Date();
        SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy H:m:s");
        Calendar c1 = null;
        if(fechaFin!=null && fechaFin.compareTo("")!=0){
            //baneo por calendario
            try {
                fecha_baneo = formato.parse(fechaFin+" 00:00:00");
            } catch (Exception ex) { log.debug("[baneo] Error al parsear la fecha.",ex); }

            log.debug("[banear] Baneo por calendario: " +fecha_baneo.toString());
        }else{

            c1 = Calendar.getInstance();

            //baneo con dias y horas
            if(dias!=null && dias.compareTo("")!=0 && horas!=0){
                c1.add(Calendar.DATE,Integer.parseInt(dias)); //le suma los días
                c1.add(Calendar.HOUR, horas);                 //se sumo las horas
                try {
                    fecha_baneo = formato.parse(formato.format(c1.getTime()));
                } catch (Exception ex) { log.debug("[baneo] Error al parsear la fecha.",ex); }

                log.debug("[banear] Baneo por dias y horas: " + fecha_baneo);
            }else{
                //solo con horas
                if(horas!=0){
                    c1.add(Calendar.HOUR, horas);         //se sumo las horas
                    try {
                        fecha_baneo = formato.parse(formato.format(c1.getTime()));
                    }catch (Exception ex) { log.debug("[baneo] Error al parsear la fecha.",ex); }
                    log.debug("[banear] Baneo solo por horas");
                }
                //solo con dias
                if(dias!=null && dias.compareTo("")!=0){
                    c1.add(Calendar.DATE,Integer.parseInt(dias)); //le suma los días

                    try {
                        fecha_baneo = formato.parse(formato.format(c1.getTime()));
                    } catch (Exception ex) { log.debug("[baneo] Error al parsear la fecha.",ex); }
                    
                    log.debug("[banear] Baneo solo por dias: " + formato.format(c1.getTime()));
                }
            }
        }

        return fecha_baneo;
    }

    private boolean comprobacionesPreviasRegistro(){
        boolean retorno = true;

        // Comprobar longitud del nick
        if (nickMostrar.length() < longMinimoNick || nickMostrar.length() > longMaximoNick) {
            log.debug("el nick " + nickMostrar  + " tiene " + nickMostrar.length() + " caracteres");
            retorno = false;
        }

        // Se comprueba el patrón del nick
        if (!checkNick(nickMostrar)) {
            log.debug("el nick " + nickMostrar + " no cumple el patron");
            retorno = false;
        }

        // Comprobar que el nick no está en la lista de prohibidos

        Map<String, Integer> nicksProhibidos = new HashMap<String,Integer>();

        nicksProhibidos.put("basketdudes", 1);
        nicksProhibidos.put("bdudes", 1);

        nicksProhibidos.put("admin", 1);
        nicksProhibidos.put("administrador", 1);
        nicksProhibidos.put("administrator", 1);
        nicksProhibidos.put("webmaster", 1);

        nicksProhibidos.put("soporte", 1);
        nicksProhibidos.put("support", 1);
        nicksProhibidos.put("bitoon", 1);
        nicksProhibidos.put("root", 1);

        nicksProhibidos.put("marketing", 1);
        nicksProhibidos.put("news", 1);
        nicksProhibidos.put("info", 1);
        nicksProhibidos.put("basket", 1);

        nicksProhibidos.put("community", 1);
        nicksProhibidos.put("comunidad", 1);
        nicksProhibidos.put("manager", 1);

        nicksProhibidos.put("moderator", 1);
        nicksProhibidos.put("moderador", 1);

        nicksProhibidos.put("sistema", 1);
        nicksProhibidos.put("system", 1);
        nicksProhibidos.put("error", 1);
        nicksProhibidos.put("failure", 1);

        nicksProhibidos.put("superusuario", 1);
        nicksProhibidos.put("superuser", 1);

        if (nicksProhibidos.containsKey(nickMostrar)) {
            // El nick no es válido
            retorno = false;
        }

        // Comprobar que la direccion de email es válida, y si viene un símbolo +,
        // quitar el símbolo y grabar la dirección normal
        if(bsaadmin.getVersion().compareTo("completa")==0){
            //solo comprobamos el email si es la "version completa"
            if (Pattern.matches(patternEmail,email)) {
                // Es un mail correcto

                // Quitar el más (+) o los mases que haya

                int posMas = email.indexOf('+');
                int posArroba = email.indexOf('@');

                if (posMas>0) {
                    email = email.substring(0,posMas) + email.substring(posArroba, email.length());
                }
            } else {
                retorno = false;
            }
        }

        return retorno;
    }

    private boolean checkNick(String nick) {
        boolean retorno = false;

        retorno = Pattern.matches(patternNick,nick);

        return retorno;
    }

    public Object getItem(int idItem,int tipo){
        //Devuelve un item pasado su id por parámetro y el tipo que es
        EntityManager em = null;
        Query q  = null;
        Object retorno = null;

        //log.debug("[getTipoItem] ItemId: " + idItem +", tipo: " + tipo);

        try {
            em = emfBasket.createEntityManager(); // checked
           
            switch(tipo){
                case 1: //jugador
                    //log.debug("[getTipoItem] MJugador");
                    q  = em.createNamedQuery("MJugador.findById");
                    q.setParameter("id", idItem);
                    retorno = (MJugador)q.getSingleResult();
                    break;
                case 2: //ropa
                    //log.debug("[getTipoItem] Ropa");
                    q  = em.createNamedQuery("Ropa.findById");
                    q.setParameter("id", idItem);
                    retorno = (Ropa)q.getSingleResult();
                    break;
                case 3: //objeto
                    //log.debug("[getTipoItem] Objeto");
                    q  = em.createNamedQuery("Objeto.findById");
                    q.setParameter("id", idItem);
                    retorno = (Objeto)q.getSingleResult();
                    break;
                case 4: //carta
                    //log.debug("[getTipoItem] MCarta");
                    q  = em.createNamedQuery("MCarta.findById");
                    q.setParameter("id", idItem);
                    retorno = (Carta)q.getSingleResult();
                    break;
                case 5: //entrenador(NO SE USA)
                    //log.debug("[getTipoItem] Entrenador");
                    break;
                case 9: //sobre
                    //log.debug("[getTipoItem] Sobre");
                    break;
                default:
                    log.debug("[getTipoItem] Otro");
            }
        } catch (NoResultException e) {
            //log.debug("[getTipoItem] item " + idItem + " no encontrado");
        } catch (Exception e) {
            log.error("[getTipoItem]: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
        return retorno;
    }

    public String dameIngresosXHR() {

        return dameIngresosPaginado(id,cuantos);
    }

    public List<Ingreso> getIngresos(int idUsuario) {
        dameIngresosPaginado(idUsuario,BaseActionAdmin.LISTADO_INGRESOS_ELEMENTOS_POR_PAGINA);
        return getListaIngresos();
    }

    public String dameIngresosPaginado(int idUsuario,int elementos) {
        EntityManager em = null;
        List<Ingreso> retorno = null;

        int acum_ingresos = 0;

        //log.debug("[Ingreso] UsuarioId: " + idUsuario);

        try {
            em = emfBasket.createEntityManager(); // checked

            Query q  = em.createNamedQuery("Ingreso.findByUsuarioId");
            q.setParameter("idUsuario", idUsuario);
            retorno = (List<Ingreso>)q.getResultList();

            int totalRegistros = q.getResultList().size();
            log.debug("[Ingreso] totalRegistros: " + totalRegistros);
            int totalPaginas = (totalRegistros-1)/elementos + 1;

            int offset = (pagina-1) * elementos;
            int first = (pagina-1)* elementos; //primer registro
            int max = elementos; //ultimo registro

            if(!retorno.isEmpty()){
                for(Ingreso i: retorno){
                    if(i.getEstado()==0 && i.getBitoones()>0){
                        acum_ingresos += i.getBitoones();
                    }
                }
            }
            setResumenByIndex(0, acum_ingresos);
            
            q  = em.createNamedQuery("Ingreso.findByUsuarioId");
            q.setParameter("idUsuario", idUsuario);
            q.setFirstResult(first);
            q.setFirstResult(offset);
            q.setMaxResults(max);
            
            retorno = (List<Ingreso>)q.getResultList();

            setCabecera(new InfoCabeceraXHR());
            getCabecera().setCorrecto(1);
            getCabecera().setActual(getPagina());
            getCabecera().setTotal(totalPaginas);

            int p1=0, p2=0;

            if (getPagina() <= (BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA+1)) {
                p1 = 1;
                p2 = BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA*2 + 1;
            } else if (getPagina() >= (totalPaginas-BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA)) {
                p1 = totalPaginas - (BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA*2);
                p2 = totalPaginas;
            } else {
                p1 = getPagina() - BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA;
                p2 = getPagina() + BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA;
            }
            if (p1 < 1) {
                p1 = 1;
            }
            if (p2 > totalPaginas) {
                p2 = totalPaginas;
            }
            getCabecera().setPrimeraPagina(p1);
            getCabecera().setUltimaPagina(p2);
            setListaIngresos(retorno);

        } catch (NoResultException e) {
            log.debug("[getIngresos][ingresos del usuario " + idUsuario + " no encontrados]");
        } catch (EntityNotFoundException e) {
            log.error("[getIngresos] Error: ¡¡¡¡¡EntityNotFoundException!!!!!!");
        } catch (Exception e) {
            log.error("[getIngresos]: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return SUCCESS;
    }

    public List<Movimiento> getMovimientos(int idUsuario){
        dameMovimientosPaginado(idUsuario,BaseActionAdmin.LISTADO_INGRESOS_ELEMENTOS_POR_PAGINA);
        return getListaMovimientos();
    }

    public String dameMovimientosXHR() {

        return dameMovimientosPaginado(id,cuantos);
    }

    public String dameMovimientosPaginado(int idUsuario,int elementos) {
        EntityManager em = null;
        List<Movimiento> retorno = null;

        int acum_movimientos = 0;
        try {
            em = emfBasket.createEntityManager(); // checked

            Query q  = em.createNamedQuery("Movimiento.findByUsuarioId");
            q.setParameter("idUsuario", idUsuario);
            
            retorno = (List<Movimiento>)q.getResultList();

            int totalRegistros = q.getResultList().size();
            log.debug("[Movimientos] totalRegistros: " + totalRegistros);
            int totalPaginas = (totalRegistros-1)/elementos + 1;

            int offset = (pagina-1) * elementos;
            int first = (pagina-1)* elementos; //primer registro
            int max = elementos; //ultimo registro

            if(!retorno.isEmpty()){

                for(Movimiento m: retorno){
                    //sumo todas las compras en bitoones
                    if(m.getTipo()==1 && m.getValor()>0){
                        acum_movimientos += m.getValor();
                    }
                }
            }
            setResumenByIndex(1, acum_movimientos);

            q  = em.createNamedQuery("Movimiento.findByUsuarioId");
            q.setParameter("idUsuario", idUsuario);
            q.setFirstResult(first);
            q.setFirstResult(offset);
            q.setMaxResults(max);

            retorno = (List<Movimiento>)q.getResultList();

            setCabecera(new InfoCabeceraXHR());
            getCabecera().setCorrecto(1);
            getCabecera().setActual(getPagina());
            getCabecera().setTotal(totalPaginas);

            int p1=0, p2=0;

            if (getPagina() <= (BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA+1)) {
                p1 = 1;
                p2 = BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA*2 + 1;
            } else if (getPagina() >= (totalPaginas-BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA)) {
                p1 = totalPaginas - (BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA*2);
                p2 = totalPaginas;
            } else {
                p1 = getPagina() - BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA;
                p2 = getPagina() + BaseActionAdmin.LISTADO_INGRESOS_HUECOS_LADO_PAGINA;
            }
            if (p1 < 1) {
                p1 = 1;
            }
            if (p2 > totalPaginas) {
                p2 = totalPaginas;
            }
            getCabecera().setPrimeraPagina(p1);
            getCabecera().setUltimaPagina(p2);
            setListaMovimientos(retorno);

        } catch (NoResultException e) {
            log.debug("[getMovimientos][movimientos del usuario " + idUsuario + " no encontrados]");
        } catch (EntityNotFoundException e) {
            log.error("[getMovimientos] Error: ¡¡¡¡¡EntityNotFoundException!!!!!!");
        } catch (Exception e) {
            log.error("[getMovimientos]: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return SUCCESS;
    }

    public int dameGastos(int id){
        List r = getMovimientos(id);
        return getResumenByIndex(1);
    }

    public List<Torneo> getTorneosUsuario() {
        List<Torneo> retorno = null;
        EntityManager em = null;

        try {
            retorno = new ArrayList<Torneo>();

            em = emfBasket.createEntityManager(); // checked

            //torneos en los que participan los equipos del usuario(incluye los que organiza)
            Query qc = em.createNativeQuery("select * from basket.torneo where basket.torneo.id in(select distinct(torneo_id) from basket.equipo e, basket.temporada t, basket.participe p where e.usuario_id=" + getManager().getId() + " and p.equipo_id=e.id and t.id=p.temporada_id group by torneo_id)", Torneo.class);

            int totalRegistros = 0;
            if (qc.getResultList()!=null) {
                totalRegistros = qc.getResultList().size();
            }
            int totalPaginas = (totalRegistros-1)/LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA + 1;

            int offset = (getPagina()-1) * LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA;

            //qc = em.createNamedQuery("Torneo.findByUsuarioId");
            qc = em.createNativeQuery("select * from basket.torneo where basket.torneo.id in(select distinct(torneo_id) from basket.equipo e, basket.temporada t, basket.participe p where e.usuario_id=" + getManager().getId() + " and p.equipo_id=e.id and t.id=p.temporada_id group by torneo_id)", Torneo.class);
            qc.setFirstResult((getPagina()-1)*LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA);
            qc.setFirstResult(offset);
            qc.setMaxResults(LISTADO_TORNEOS_ELEMENTOS_POR_PAGINA);

            retorno = (List<Torneo>)qc.getResultList();

            log.debug("Total registros: " + totalRegistros);
            log.debug("Pagina: " + getPagina());
            log.debug("TotalPaginas: " + totalPaginas);

            setCabecera(new InfoCabeceraXHR());
            getCabecera().setCorrecto(1);
            getCabecera().setActual(getPagina());
            getCabecera().setTotal(totalPaginas);

            int p1=0, p2=0;

            if (getPagina() <= (LISTADO_TORNEOS_HUECOS_LADO_PAGINA+1)) {
                p1 = 1;
                p2 = LISTADO_TORNEOS_HUECOS_LADO_PAGINA*2 + 1;
            } else if (getPagina() >= (totalPaginas-LISTADO_TORNEOS_HUECOS_LADO_PAGINA)) {
                p1 = totalPaginas - (LISTADO_TORNEOS_HUECOS_LADO_PAGINA*2);
                p2 = totalPaginas;
            } else {
                p1 = getPagina() - LISTADO_TORNEOS_HUECOS_LADO_PAGINA;
                p2 = getPagina() + LISTADO_TORNEOS_HUECOS_LADO_PAGINA;
            }
            if (p1 < 1) {
                p1 = 1;
            }
            if (p2 > totalPaginas) {
                p2 = totalPaginas;
            }
            getCabecera().setPrimeraPagina(p1);
            getCabecera().setUltimaPagina(p2);

        } catch (Exception e) {
            log.error("[TorneosUsuario]: Error: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }
        return retorno;
    }

    public Temporada getTemporadaActiva(int idTorneo) {
        EntityManager em = null;
        Temporada retorno = null;

        try {
            em = emfBasket.createEntityManager(); // checked
            log.debug("Buscando temporada activa ..." + idTorneo);

            Query q = em.createNamedQuery("Temporada.findTemporadaActivaByTorneoId");
            q.setParameter("id", idTorneo);
            q.setMaxResults(1);
            retorno = (Temporada)q.getSingleResult();
            //.debug("temp. activa: " + retorno);
        } catch (NoResultException nre) {
        } catch (Exception e) {
            log.error("Error en getTemporadaActiva: ", e);
        } finally {
            try { em.close(); } catch (Exception e) { }
        }

        return retorno;
    }

    public List<Calendario> getCalendarioTemporadaActiva(int temporada_id){
        List<Calendario> retorno = null;
        EntityManager em = null;

        log.debug("[Calendario] temporada_id: " + temporada_id);

        try {
            retorno = new ArrayList<Calendario>();
            em = emfBasket.createEntityManager(); // checked
            Query qc = em.createNamedQuery("Calendario.findByTemporadaId");
            qc.setParameter("temporadaId", temporada_id);

            retorno = qc.getResultList();

        } catch (NoResultException nre) {
            log.debug("[getCalendarioTemporadaActiva] No se ha encontrado el calendario");
        } catch (EntityNotFoundException e) {
            log.error("[getCalendarioTemporadaActiva] Error: EntityNotFoundException");
        } catch (Exception e) {
            log.error("[getCalendarioTemporadaActiva] Error ", e);
        } finally {
            try { if (em.getTransaction().isActive()) { em.getTransaction().rollback();} }catch (Exception e) { }
            try { em.close(); } catch (Exception e) { log.error("Error: ", e); }
        }

        return retorno;
    }

    public String operacionFinanciera(){
        String retorno = SUCCESS;

        EntityManager em = null;

        try {
            em = emfBasket.createEntityManager(); // checked
            
            //setCabecera(new InfoCabeceraXHR());
            //getCabecera().setCorrecto(1);

            /*resumen[0] = 0;
            resumen[1] = 0;
            resumen[2] = 0;*/

            int bitoones = Integer.parseInt(bitoons);

            //si queremos restarle o sumarle +/-99999 bitoones que es el máximo
            if(bitoones!=0 && (bitoones>=-999999 && bitoones<=999999))
            {
                //solo sumamos o restamos,no ponemos un ingreso de 0 bitoones en la BD
                Query q = em.createNamedQuery("Usuario.findById");
                q.setParameter("id", id);
                Usuario existsUser = new Usuario();
                existsUser = (Usuario)q.getSingleResult();
                log.debug("[operacionFinanciera] existsUser: " + existsUser);
                if (existsUser==null) {
                    // The user doesn't exist
                    //getCabecera().setCorrecto(0);
                    retorno="error";
                } else {
                    //Sumamos o restamos dependiendo del signo
                    Ingreso deposit = new Ingreso();
                    float currentBitoons = existsUser.getCreditos();
                    if(bitoones>0){
                        log.debug("sumo" + currentBitoons);
                    }else{
                        log.debug("resto " + currentBitoons);
                    }
                    //comprobamos que no nos pasemos de las cantidades límite
                    currentBitoons+=bitoones;
                    if(currentBitoons>999999){
                        currentBitoons = 999999;
                    }else{
                        if(currentBitoons<-999999){
                            currentBitoons=-999999;
                        }
                    }
                    log.debug("[operacionFinanciera] current:" + currentBitoons);
                    deposit.setUsuarioId(existsUser.getId());
                    deposit.setBitoones(bitoones);
                    deposit.setFPeticion(new Date());
                    deposit.setFFin(new Date());
                    deposit.setMoneda("");
                    deposit.setClave("");
                    deposit.setPasarelaId((short)99);
                    deposit.setImporte(BigDecimal.ZERO);
                    deposit.setComision(BigDecimal.ZERO);
                    log.debug("[id ingreso] id: " + bitoones);

                    if(currentBitoons==-999999 || currentBitoons==999999){
                        existsUser.setCreditos(currentBitoons);
                    }else{
                        existsUser.setCreditos(existsUser.getCreditos()+bitoones);
                    }

                    //actualizamos los bitoones de un usuario con la cantidad pasada
                    em.getTransaction().begin();
                    em.persist(deposit);
                    em.persist(existsUser);
                    em.getTransaction().commit();

                    //calculo sus gastos actuales, los gastos se acumulan en resumen en el indice 1 de ese array
                    List r = getMovimientos(id);
                    
                    /*resumen[0] = (int)currentBitoons;
                    resumen[1] = getResumenByIndex(1);
                    resumen[2] = resumen[0] - resumen[1];*/
                }
            }else{
                //devolvemos 0 porque no queremos actualizar el resumen financiero
                //getCabecera().setCorrecto(0);
                retorno="error";
            }
        } catch (Exception e) {
            log.error("[operacionFinanciera] Error ", e);
            //getCabecera().setCorrecto(0);
            retorno="error";
        } finally {
            try { if (em.getTransaction().isActive()) { em.getTransaction().rollback();} }catch (Exception e) { }
            try { em.close(); } catch (Exception e) { log.error("[operacionFinancieraXHR] Error: ", e); }
        }
        return retorno;
    }

    public String getNick() {
        return nick;
    }

    public void setNick(String nick) {
        this.nick = nick;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int estado) {
        this.status = estado;
    }

    public int getRobinson() {
        return robinson;
    }

    public void setRobinson(int newsletter) {
        this.robinson = newsletter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public boolean isModificar() {
        return modificar;
    }

    public void setModificar(boolean modificar) {
        this.modificar = modificar;
    }

    public String getNickMostrar() {
        return nickMostrar;
    }

    public void setNickMostrar(String nickMostrar) {
        this.nickMostrar = nickMostrar;
    }

    public boolean isError() {
        return error;
    }

    public void setError(boolean error) {
        this.error = error;
    }

    public List<Torneo> getTorneos() {
        return torneos;
    }

    public void setTorneos(List<Torneo> torneos) {
        this.torneos = torneos;
    }

    public InfoCabeceraXHR getCabecera() {
        return cabecera;
    }

    public void setCabecera(InfoCabeceraXHR cabecera) {
        this.cabecera = cabecera;
    }

    public int getPagina() {
        return pagina;
    }

    public void setPagina(int pagina) {
        this.pagina = pagina;
    }

    public int getCuantos() {
        return cuantos;
    }

    public void setCuantos(int cuantos) {
        this.cuantos = cuantos;
    }

    public boolean isEstado() {
        return estado;
    }

    public void setEstado(boolean estado) {
        this.estado = estado;
    }

    public int getReputacion() {
        return reputacion;
    }

    public void setReputacion(int reputacion) {
        this.reputacion = reputacion;
    }

    public int[] getResumen() {
        return resumen;
    }

    public void setResumen(int[] resumen) {
        this.resumen = resumen;
    }

    public int getResumenByIndex(int index) {
        return resumen[index];
    }

    public void setResumenByIndex(int index,int dato) {
        resumen[index] = dato;
    }

    public String getBitoons() {
        return bitoons;
    }

    public void setBitoons(String ingresos) {
        this.bitoons = ingresos;
    }

    public List<Ingreso> getListaIngresos() {
        return listaIngresos;
    }

    public void setListaIngresos(List<Ingreso> listaIngresos) {
        this.listaIngresos = listaIngresos;
    }

    public List<Movimiento> getListaMovimientos() {
        return listaMovimientos;
    }

    public void setListaMovimientos(List<Movimiento> listaMovimientos) {
        this.listaMovimientos = listaMovimientos;
    }

    public int getSeccion() {
        return seccion;
    }

    public void setSeccion(int seccion) {
        this.seccion = seccion;
    }

    public String getDias() {
        return dias;
    }

    public void setDias(String dias) {
        this.dias = dias;
    }

    public int getHoras() {
        return horas;
    }

    public void setHoras(int horas) {
        this.horas = horas;
    }

    public String getFechaFin() {
        return fechaFin;
    }

    public void setFechaFin(String fechaFin) {
        this.fechaFin = fechaFin;
    }

    public boolean isError_patron() {
        return error_patron;
    }

    public void setError_patron(boolean error_patron) {
        this.error_patron = error_patron;
    }

    public BaseActionAdmin getBsaadmin() {
        return bsaadmin;
    }

    public void setBsaadmin(BaseActionAdmin bsaadmin) {
        this.bsaadmin = bsaadmin;
    }
}


